package com.lxw.nonghe.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxw.nonghe.entity.RolePermission;
import com.lxw.nonghe.mapper.RolePermissionMapper;
import com.lxw.nonghe.service.RolePermissionService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class RolePermissionServiceImpl extends ServiceImpl<RolePermissionMapper, RolePermission> implements RolePermissionService {

    /**
     * 批量添加角色权限关联（先删除旧关联再添加新关联，避免重复）
     * @param roleId 角色ID
     * @param permissionIds 权限ID列表
     * @return 添加结果
     */
    @Override
    @Transactional // 启用事务保证数据一致性
    public boolean batchAdd(Integer roleId, List<Integer> permissionIds) {
        // 先删除该角色原有的所有权限关联（如需保留历史记录可省略此步骤）
        removeByRoleId(roleId);

        // 生成新的角色权限关联列表
        List<RolePermission> rolePermissions = permissionIds.stream()
                .map(permissionId -> new RolePermission(roleId, permissionId))
                .collect(Collectors.toList());

        // 批量插入数据库
        return saveBatch(rolePermissions);
    }

    /**
     * 批量删除角色权限关联
     * @param roleId 角色ID
     * @param permissionIds 权限ID列表
     * @return 删除结果
     */
    @Override
    @Transactional
    public boolean batchDelete(Integer roleId, List<Integer> permissionIds) {
        // 构建删除条件：角色ID + 权限ID在列表中
        LambdaQueryWrapper<RolePermission> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(RolePermission::getRoleId, roleId)
                .in(RolePermission::getPermissionId, permissionIds);

        return remove(queryWrapper);
    }

    /**
     * 根据角色ID查询权限ID列表
     * @param roleId 角色ID
     * @return 权限ID列表
     */
    @Override
    public List<Integer> getPermissionsByRole(Integer roleId) {
        return list(new LambdaQueryWrapper<RolePermission>()
                .eq(RolePermission::getRoleId, roleId))
                .stream()
                .map(RolePermission::getPermissionId)
                .collect(Collectors.toList());
    }

    /**
     * 根据权限ID查询角色ID列表
     * @param permissionId 权限ID
     * @return 角色ID列表
     */
    @Override
    public List<Integer> getRolesByPermission(Integer permissionId) {
        return list(new LambdaQueryWrapper<RolePermission>()
                .eq(RolePermission::getPermissionId, permissionId))
                .stream()
                .map(RolePermission::getRoleId)
                .collect(Collectors.toList());
    }

    /**
     * 私有方法：根据角色ID删除所有权限关联
     * @param roleId 角色ID
     */
    private void removeByRoleId(Integer roleId) {
        LambdaQueryWrapper<RolePermission> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(RolePermission::getRoleId, roleId);
        remove(queryWrapper);
    }

}
